folder_registry.h

Go to the documentation of this file.

// WOLF - Copyright (C) 2020-2026
// Institut de Robòtica i Informàtica Industrial, CSIC-UPC.
// Authors: Joan Solà Ortega (jsola@iri.upc.edu) and
// Joan Vallvé Navarro (jvallve@iri.upc.edu)
// All rights reserved.
//
// This file is part of WOLF: http://www.iri.upc.edu/wolf
// WOLF is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 3
// as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
 
#include "core/utils/unused.h"
 
// std
#include <string>
#include <map>
#include <vector>
#include <iostream>
#include <iomanip>
 
namespace wolf
{
class FolderRegistry
{
  private:
    std::map<std::string, std::string> folders_;
 
  public:
    static bool                     registerFolder(const std::string& _plugin, const std::string _folder);
    static bool                     unregisterFolder(const std::string& _plugin);
    static bool                     isFolderRegistered(const std::string& _plugin);
    static void                     printAddress();
    static std::vector<std::string> getRegisteredFolders();
    static void                     appendRegisteredFolders(std::vector<std::string>& _folders);
 
    // Singleton ---------------------------------------------------
    // This class is a singleton. The code below guarantees this.
    // See: http://stackoverflow.com/questions/1008019/c-singleton-design-pattern
  private:
    static FolderRegistry& get();
 
  public:
    FolderRegistry(const FolderRegistry&) = delete;
    void operator=(FolderRegistry const&) = delete;
 
  private:
    FolderRegistry();
    ~FolderRegistry();
};
 
inline FolderRegistry::FolderRegistry()
{
    // std::cout << " FolderRegistry constructor  " << std::endl;
}
 
inline FolderRegistry::~FolderRegistry()
{
    // std::cout << " FolderRegistry destructor  " << std::endl;}
}
 
inline bool FolderRegistry::registerFolder(const std::string& _plugin, const std::string _folder)
{
    // Unregister plugin-folder if registered with different folder
    if (get().isFolderRegistered(_plugin) and get().folders_.at(_plugin) != _folder)
    {
        std::cout << std::setw(31) << std::left << "FolderRegistry"
                  << " XXX unregister old '" << _plugin << "' folder: " << get().folders_.at(_plugin) << std::endl;
        get().unregisterFolder(_plugin);
    }
 
    // register plugin-folder if not registered
    if (not get().isFolderRegistered(_plugin))
    {
        get().folders_.insert(std::pair<std::string, std::string>(_plugin, _folder)).second;
        std::cout << std::setw(31) << std::left << "FolderRegistry"
                  << " <-- registered  '" << _plugin << "' folder: " << _folder << std::endl;
        return true;
    }
 
    return false;
}
 
inline bool FolderRegistry::unregisterFolder(const std::string& _plugin)
{
    if (get().isFolderRegistered(_plugin))
        return get().folders_.erase(_plugin) == 1;
    else
        std::cout << std::setw(31) << std::left << "FolderRegistry"
                  << " ERROR trying to unregister " << _plugin << ": Not registered." << std::endl;
    return false;
}
 
inline bool FolderRegistry::isFolderRegistered(const std::string& _plugin)
{
    return get().folders_.count(_plugin);
}
 
inline FolderRegistry& FolderRegistry::get()
{
    static FolderRegistry instance_;
    return instance_;
}
 
inline void FolderRegistry::printAddress()
{
    std::cout << "FolderRegistry address: " << &get() << std::endl;
}
 
inline std::vector<std::string> FolderRegistry::getRegisteredFolders()
{
    std::vector<std::string> vec;
    for (auto pair : get().folders_) vec.push_back(pair.second);
    return vec;
}
 
inline void FolderRegistry::appendRegisteredFolders(std::vector<std::string>& _folders)
{
    for (auto pair : get().folders_) _folders.push_back(pair.second);
}
 
}  // namespace wolf
 
#define WOLF_REGISTER_FOLDER(plugin, folder)                                                                          \
    namespace                                                                                                         \
    {                                                                                                                 \
    const bool WOLF_UNUSED folder##Registered = FolderRegistry::registerFolder(plugin, folder);                       \
    }